package com.gemini.utis;


import com.gemini.core.pools.PatternPool;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StrUtil {

    /**
     * 判断字符串是否为null 或 长度为0
     *
     * @param str 源字符串
     * @return 为空则返回ture
     */
    public static boolean isEmpty(CharSequence str) {
        return str == null || str.length() == 0;
    }

    public static boolean isNotEmpty(CharSequence str) {
        return !isEmpty(str);
    }


    /**
     * 使用args参数顺序填补 文本中{}的位置。
     *
     * @param originStr 源文本
     * @param args      实际参数
     * @return e.g input: (Hello {},World)  output: Hello World
     */
    public static String format(CharSequence originStr, Object... args) {
        if (isEmpty(originStr) || args == null || args.length == 0) {
            return originStr.toString();
        }

        Matcher matcher = PatternPool.PLACEHOLDER.matcher(originStr);

        StringBuilder result = new StringBuilder(originStr);

        //补充参数的位数
        int argLength = args.length;
        //{}固定为两位 因为正则只判定一次这里记录长度变化，保证替换位置的正确
        int supplementLength = 0;
        //当前参数坐标位置
        int argIndex = 0;

        while (matcher.find() && argIndex < argLength) {

            Object arg = args[argIndex];
            String argStr = arg == null ? "null" : arg.toString();

            result.replace(supplementLength + matcher.start(), supplementLength + matcher.end(), argStr);

            supplementLength += argStr.length() - 2;
            argIndex++;
        }

        return result.toString();
    }


    /**
     * 特定字符（串）出现的次数
     *
     * @param originStr  源字符
     * @param specifyStr 特定字符
     * @return 出现数量
     */
    public static int strOccurCount(CharSequence originStr, CharSequence specifyStr) {
        return strOccurCount(originStr, specifyStr, false);
    }

    /**
     * 特定字符（串）出现的次数
     *
     * @param originStr  源字符
     * @param specifyStr 特定字符
     * @param matchCase  匹配大小写 默认false
     * @return 出现数量
     */
    public static int strOccurCount(CharSequence originStr, CharSequence specifyStr, boolean matchCase) {

        if (isEmpty(originStr) || isEmpty(specifyStr)) {
            return 0;
        }

        String regex = specifyStr.toString();

        Pattern pattern;
        if (matchCase) {
            pattern = Pattern.compile(regex);
        } else {
            pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        }
        Matcher matcher = pattern.matcher(originStr);
        int count = 0;
        while (matcher.find()) {
            count++;
        }
        return count;
    }


    /**
     * 去除源文本中指定的字符
     *
     * @param originStr 源文本
     * @param args      需要去除的字符，特殊符号请使用{@link com.gemini.core.pools.RegexPool}提供的枚举字段
     * @return 去除指定字符后的文本
     */
    public static String clearStr(CharSequence originStr, CharSequence... args) {
        if (originStr == null) {
            return null;
        }
        if (args.length == 0) {
            return originStr.toString();
        }
        String join = String.join("|", args);

        String string = originStr.toString();

        return string.replaceAll(join, "");
    }

}
